defineSuite([
        'Widgets/Animation/AnimationViewModel',
        'Core/ClockRange',
        'Core/ClockStep',
        'Core/JulianDate',
        'Widgets/ClockViewModel'
    ], function(
        AnimationViewModel,
        ClockRange,
        ClockStep,
        JulianDate,
        ClockViewModel) {
    'use strict';

    var clockViewModel;
    beforeEach(function() {
        clockViewModel = new ClockViewModel();
    });

    function verifyPausedState(viewModel) {
        expect(viewModel.pauseViewModel.toggled).toEqual(true);
        expect(viewModel.playReverseViewModel.toggled).toEqual(false);
        expect(viewModel.playForwardViewModel.toggled).toEqual(false);
        expect(viewModel.playRealtimeViewModel.toggled).toEqual(false);
    }

    function verifyForwardState(viewModel) {
        expect(viewModel.pauseViewModel.toggled).toEqual(false);
        expect(viewModel.playReverseViewModel.toggled).toEqual(false);
        expect(viewModel.playForwardViewModel.toggled).toEqual(true);
        expect(viewModel.playRealtimeViewModel.toggled).toEqual(false);
    }

    function verifyReverseState(viewModel) {
        expect(viewModel.pauseViewModel.toggled).toEqual(false);
        expect(viewModel.playReverseViewModel.toggled).toEqual(true);
        expect(viewModel.playForwardViewModel.toggled).toEqual(false);
        expect(viewModel.playRealtimeViewModel.toggled).toEqual(false);
    }

    function verifyRealtimeState(viewModel) {
        expect(viewModel.pauseViewModel.toggled).toEqual(false);
        expect(viewModel.playReverseViewModel.toggled).toEqual(false);
        expect(viewModel.playForwardViewModel.toggled).toEqual(false);
        expect(viewModel.playRealtimeViewModel.toggled).toEqual(true);
        expect(viewModel.shuttleRingAngle).toEqual(AnimationViewModel._realtimeShuttleRingAngle);
    }

    it('constructor sets expected properties', function() {
        var animationViewModel = new AnimationViewModel(clockViewModel);
        expect(animationViewModel.clockViewModel).toBe(clockViewModel);
    });

    it('setTimeFormatter overrides the default formatter', function() {
        var animationViewModel = new AnimationViewModel(clockViewModel);

        var expectedString = 'My Time';
        var myCustomFormatter = function(date) {
            expect(date).toEqual(clockViewModel.currentTime);
            return expectedString;
        };
        animationViewModel.timeFormatter = myCustomFormatter;

        expect(animationViewModel.timeLabel).toEqual(expectedString);
        expect(animationViewModel.timeFormatter).toEqual(myCustomFormatter);
    });

    it('defaultTimeFormatter produces expected result', function() {
        var animationViewModel = new AnimationViewModel(clockViewModel);

        var date = JulianDate.fromIso8601('2012-03-05T06:07:08.89Z');

        clockViewModel.multiplier = 1;
        var expectedResult = '06:07:08 UTC';
        var result = animationViewModel.timeFormatter(date, animationViewModel);
        expect(result).toEqual(expectedResult);

        clockViewModel.multiplier = -1;
        expectedResult = '06:07:08 UTC';
        result = animationViewModel.timeFormatter(date, animationViewModel);
        expect(result).toEqual(expectedResult);

        clockViewModel.multiplier = -0.5;
        expectedResult = '06:07:08.890';
        result = animationViewModel.timeFormatter(date, animationViewModel);
        expect(result).toEqual(expectedResult);

        clockViewModel.multiplier = 0.5;
        expectedResult = '06:07:08.890';
        result = animationViewModel.timeFormatter(date, animationViewModel);
        expect(result).toEqual(expectedResult);
    });

    it('setDateFormatter overrides the default formatter', function() {
        var animationViewModel = new AnimationViewModel(clockViewModel);

        var expectedString = 'My Date';
        var myCustomFormatter = function(date) {
            expect(date).toEqual(clockViewModel.currentTime);
            return expectedString;
        };
        animationViewModel.dateFormatter = myCustomFormatter;

        expect(animationViewModel.dateLabel).toEqual(expectedString);
        expect(animationViewModel.dateFormatter).toEqual(myCustomFormatter);
    });

    it('defaultDateFormatter produces expected result', function() {
        var animationViewModel = new AnimationViewModel(new ClockViewModel());

        var date = JulianDate.fromIso8601('2012-01-05T06:07:08.89Z');
        var expectedResult = 'Jan 5 2012';
        var result = animationViewModel.dateFormatter(date, animationViewModel);
        expect(result).toEqual(expectedResult);

        date = JulianDate.fromIso8601('2012-02-05T06:07:08.89Z');
        expectedResult = 'Feb 5 2012';
        result = animationViewModel.dateFormatter(date, animationViewModel);
        expect(result).toEqual(expectedResult);

        date = JulianDate.fromIso8601('2012-03-05T06:07:08.89Z');
        expectedResult = 'Mar 5 2012';
        result = animationViewModel.dateFormatter(date, animationViewModel);
        expect(result).toEqual(expectedResult);

        date = JulianDate.fromIso8601('2012-04-05T06:07:08.89Z');
        expectedResult = 'Apr 5 2012';
        result = animationViewModel.dateFormatter(date, animationViewModel);
        expect(result).toEqual(expectedResult);

        date = JulianDate.fromIso8601('2012-05-05T06:07:08.89Z');
        expectedResult = 'May 5 2012';
        result = animationViewModel.dateFormatter(date, animationViewModel);
        expect(result).toEqual(expectedResult);

        date = JulianDate.fromIso8601('2012-06-05T06:07:08.89Z');
        expectedResult = 'Jun 5 2012';
        result = animationViewModel.dateFormatter(date, animationViewModel);
        expect(result).toEqual(expectedResult);

        date = JulianDate.fromIso8601('2012-07-05T06:07:08.89Z');
        expectedResult = 'Jul 5 2012';
        result = animationViewModel.dateFormatter(date, animationViewModel);
        expect(result).toEqual(expectedResult);

        date = JulianDate.fromIso8601('2012-08-05T06:07:08.89Z');
        expectedResult = 'Aug 5 2012';
        result = animationViewModel.dateFormatter(date, animationViewModel);
        expect(result).toEqual(expectedResult);

        date = JulianDate.fromIso8601('2012-09-05T06:07:08.89Z');
        expectedResult = 'Sep 5 2012';
        result = animationViewModel.dateFormatter(date, animationViewModel);
        expect(result).toEqual(expectedResult);

        date = JulianDate.fromIso8601('2012-10-05T06:07:08.89Z');
        expectedResult = 'Oct 5 2012';
        result = animationViewModel.dateFormatter(date, animationViewModel);
        expect(result).toEqual(expectedResult);

        date = JulianDate.fromIso8601('2012-11-05T06:07:08.89Z');
        expectedResult = 'Nov 5 2012';
        result = animationViewModel.dateFormatter(date, animationViewModel);
        expect(result).toEqual(expectedResult);

        date = JulianDate.fromIso8601('2012-12-05T06:07:08.89Z');
        expectedResult = 'Dec 5 2012';
        result = animationViewModel.dateFormatter(date, animationViewModel);
        expect(result).toEqual(expectedResult);
    });

    it('correctly formats speed label', function() {
        var animationViewModel = new AnimationViewModel(clockViewModel);
        var expectedString;

        clockViewModel.clockStep = ClockStep.TICK_DEPENDENT;
        clockViewModel.multiplier = 123.1;
        expectedString = '123.1x';
        expect(animationViewModel.multiplierLabel).toEqual(expectedString);

        clockViewModel.clockStep = ClockStep.TICK_DEPENDENT;
        clockViewModel.multiplier = 123.12;
        expectedString = '123.12x';
        expect(animationViewModel.multiplierLabel).toEqual(expectedString);

        clockViewModel.clockStep = ClockStep.TICK_DEPENDENT;
        clockViewModel.multiplier = 123.123;
        expectedString = '123.123x';
        expect(animationViewModel.multiplierLabel).toEqual(expectedString);

        clockViewModel.clockStep = ClockStep.TICK_DEPENDENT;
        clockViewModel.multiplier = 123.1236;
        expectedString = '123.124x';
        expect(animationViewModel.multiplierLabel).toEqual(expectedString);

        clockViewModel.clockStep = ClockStep.SYSTEM_CLOCK;
        expectedString = 'Today';
        expect(animationViewModel.multiplierLabel).toEqual(expectedString);

        clockViewModel.clockStep = ClockStep.TICK_DEPENDENT;
        clockViewModel.multiplier = 15;
        expectedString = '15x';
        expect(animationViewModel.multiplierLabel).toEqual(expectedString);
    });

    it('pause button restores current state', function() {
        clockViewModel.startTime = JulianDate.fromIso8601("2012-01-01T00:00:00");
        clockViewModel.stopTime = JulianDate.fromIso8601("2012-01-02T00:00:00");
        clockViewModel.currentTime = JulianDate.fromIso8601("2012-01-01T12:00:00");
        clockViewModel.multiplier = 1;
        clockViewModel.clockStep = ClockStep.TICK_DEPENDENT;
        clockViewModel.clockRange = ClockRange.UNBOUNDED;
        clockViewModel.shouldAnimate = false;

        var viewModel = new AnimationViewModel(clockViewModel);

        //Starts out paused
        verifyPausedState(viewModel);

        //Toggling paused restores state when animating forward
        viewModel.pauseViewModel.command();

        verifyForwardState(viewModel);

        //Executing paused command restores paused state
        viewModel.pauseViewModel.command();

        verifyPausedState(viewModel);

        //Setting the multiplier to negative and unpausing animates backward
        clockViewModel.multiplier = -1;
        viewModel.pauseViewModel.command();

        verifyReverseState(viewModel);
    });

    it('animating forwards negates the multiplier if it is negative', function() {
        var viewModel = new AnimationViewModel(clockViewModel);
        var multiplier = -100;
        clockViewModel.multiplier = multiplier;
        viewModel.playForwardViewModel.command();
        expect(clockViewModel.multiplier).toEqual(-multiplier);
    });

    it('animating backwards negates the multiplier if it is positive', function() {
        var viewModel = new AnimationViewModel(clockViewModel);
        var multiplier = 100;
        clockViewModel.multiplier = multiplier;
        viewModel.playReverseViewModel.command();
        expect(clockViewModel.multiplier).toEqual(-multiplier);
    });

    it('animating backwards pauses with a bounded startTime', function() {
        var centerTime = JulianDate.fromIso8601("2012-01-01T12:00:00");

        clockViewModel.startTime = JulianDate.fromIso8601("2012-01-01T00:00:00");
        clockViewModel.stopTime = JulianDate.fromIso8601("2012-01-02T00:00:00");
        clockViewModel.clockStep = ClockStep.TICK_DEPENDENT;
        clockViewModel.currentTime = centerTime;
        clockViewModel.shouldAnimate = false;

        var viewModel = new AnimationViewModel(clockViewModel);
        verifyPausedState(viewModel);

        //Play in reverse while clamped
        clockViewModel.multiplier = -1;
        clockViewModel.clockRange = ClockRange.CLAMPED;
        viewModel.playReverseViewModel.command();

        verifyReverseState(viewModel);

        //Set current time to start time
        clockViewModel.currentTime = clockViewModel.startTime;

        //Should now be paused
        verifyPausedState(viewModel);

        //Animate in reverse again.
        clockViewModel.currentTime = centerTime;
        clockViewModel.clockRange = ClockRange.LOOP_STOP;
        viewModel.playReverseViewModel.command();

        verifyReverseState(viewModel);

        //Set current time to start time
        clockViewModel.currentTime = clockViewModel.startTime;

        //Should now be paused
        verifyPausedState(viewModel);

        //Reversing in start state while bounded should have no effect
        viewModel.playReverseViewModel.command();
        verifyPausedState(viewModel);

        //Set to unbounded and reversing should be okay
        clockViewModel.clockRange = ClockRange.UNBOUNDED;
        viewModel.playReverseViewModel.command();
        verifyReverseState(viewModel);
    });

    it('dragging shuttle ring does not pause with bounded start or stop Time', function() {
        var centerTime = JulianDate.fromIso8601("2012-01-01T12:00:00");

        clockViewModel.startTime = JulianDate.fromIso8601("2012-01-01T00:00:00");
        clockViewModel.stopTime = JulianDate.fromIso8601("2012-01-02T00:00:00");
        clockViewModel.clockStep = ClockStep.TICK_DEPENDENT;
        clockViewModel.clockRange = ClockRange.CLAMPED;
        clockViewModel.multiplier = 1;

        var viewModel = new AnimationViewModel(clockViewModel);
        verifyPausedState(viewModel);

        //Play forward while clamped
        clockViewModel.currentTime = centerTime;
        viewModel.playForwardViewModel.command();
        verifyForwardState(viewModel);

        //Set current time to stop time, which won't stop while dragging
        viewModel.shuttleRingDragging = true;
        clockViewModel.currentTime = clockViewModel.stopTime;
        verifyForwardState(viewModel);

        //Drag complete stops.
        viewModel.shuttleRingDragging = false;
        verifyPausedState(viewModel);

        //Do the same thing with start time
        clockViewModel.currentTime = centerTime;
        viewModel.playReverseViewModel.command();
        verifyReverseState(viewModel);

        viewModel.shuttleRingDragging = true;
        clockViewModel.currentTime = clockViewModel.startTime;
        verifyReverseState(viewModel);

        //Drag complete stops.
        viewModel.shuttleRingDragging = false;
        verifyPausedState(viewModel);
    });

    it('animating forward pauses with a bounded stopTime', function() {
        var centerTime = JulianDate.fromIso8601("2012-01-01T12:00:00");

        clockViewModel.startTime = JulianDate.fromIso8601("2012-01-01T00:00:00");
        clockViewModel.stopTime = JulianDate.fromIso8601("2012-01-02T00:00:00");
        clockViewModel.clockStep = ClockStep.TICK_DEPENDENT;
        clockViewModel.currentTime = centerTime;
        clockViewModel.shouldAnimate = false;

        var viewModel = new AnimationViewModel(clockViewModel);
        verifyPausedState(viewModel);

        //Play forward while clamped
        clockViewModel.multiplier = 1;
        clockViewModel.clockRange = ClockRange.CLAMPED;
        viewModel.playForwardViewModel.command();

        verifyForwardState(viewModel);

        //Set current time to stop time
        clockViewModel.currentTime = clockViewModel.stopTime;

        //Should now be paused
        verifyPausedState(viewModel);

        //Playing in stop state while bounded should have no effect
        viewModel.playForwardViewModel.command();
        verifyPausedState(viewModel);

        //Set to unbounded and playing should be okay
        clockViewModel.clockRange = ClockRange.UNBOUNDED;
        viewModel.playForwardViewModel.command();
        verifyForwardState(viewModel);
    });

    it('slower has no effect if at the slowest speed', function() {
        var viewModel = new AnimationViewModel(clockViewModel);
        viewModel.setShuttleRingTicks([0.0, 1.0, 2.0]);
        var slowestMultiplier = -2;
        clockViewModel.multiplier = slowestMultiplier;
        viewModel.slower();
        expect(clockViewModel.multiplier).toEqual(slowestMultiplier);
    });

    it('faster has no effect if at the faster speed', function() {
        var viewModel = new AnimationViewModel(clockViewModel);
        viewModel.setShuttleRingTicks([0.0, 1.0, 2.0]);
        var fastestMultiplier = 2;
        clockViewModel.multiplier = fastestMultiplier;
        viewModel.faster();
        expect(clockViewModel.multiplier).toEqual(fastestMultiplier);
    });

    it('slower and faster cycle through defined multipliers', function() {
        var viewModel = new AnimationViewModel(clockViewModel);

        var i = 0;
        var multipliers = viewModel.getShuttleRingTicks();
        var length = multipliers.length;

        //Start at slowest speed
        clockViewModel.multiplier = multipliers[0];

        //Cycle through them all with faster
        for (i = 1; i < length; i++) {
            viewModel.faster();
            expect(clockViewModel.multiplier).toEqual(multipliers[i]);
        }

        //We should be at the fastest time now.
        expect(clockViewModel.multiplier).toEqual(multipliers[length - 1]);

        //Cycle through them all with slower
        for (i = length - 2; i >= 0; i--) {
            viewModel.slower();
            expect(clockViewModel.multiplier).toEqual(multipliers[i]);
        }

        //We should be at the slowest time now.
        expect(clockViewModel.multiplier).toEqual(multipliers[0]);
    });

    it('Realtime canExecute and tooltip depends on clock settings', function() {
        var viewModel = new AnimationViewModel(clockViewModel);

        //UNBOUNDED but available when start/stop time does not include realtime
        clockViewModel.systemTime = JulianDate.now();
        clockViewModel.clockRange = ClockRange.UNBOUNDED;
        clockViewModel.startTime = JulianDate.addSeconds(clockViewModel.systemTime, -60, new JulianDate());
        clockViewModel.stopTime = JulianDate.addSeconds(clockViewModel.systemTime, -30, new JulianDate());
        expect(viewModel.playRealtimeViewModel.command.canExecute).toEqual(true);
        expect(viewModel.playRealtimeViewModel.tooltip).toEqual('Today (real-time)');

        //CLAMPED but unavailable when start/stop time does not include realtime
        clockViewModel.clockRange = ClockRange.CLAMPED;
        clockViewModel.startTime = JulianDate.addSeconds(clockViewModel.systemTime, -60, new JulianDate());
        clockViewModel.stopTime = JulianDate.addSeconds(clockViewModel.systemTime, -30, new JulianDate());
        expect(viewModel.playRealtimeViewModel.command.canExecute).toEqual(false);
        expect(viewModel.playRealtimeViewModel.tooltip).toEqual('Current time not in range');

        //CLAMPED but available when start/stop time includes realtime
        clockViewModel.clockRange = ClockRange.CLAMPED;
        clockViewModel.startTime = JulianDate.addSeconds(clockViewModel.systemTime, -60, new JulianDate());
        clockViewModel.stopTime = JulianDate.addSeconds(clockViewModel.systemTime, 60, new JulianDate());
        expect(viewModel.playRealtimeViewModel.command.canExecute).toEqual(true);
        expect(viewModel.playRealtimeViewModel.tooltip).toEqual('Today (real-time)');

        //LOOP_STOP but unavailable when start/stop time does not include realtime
        clockViewModel.clockRange = ClockRange.LOOP_STOP;
        clockViewModel.startTime = JulianDate.addSeconds(clockViewModel.systemTime, -60, new JulianDate());
        clockViewModel.stopTime = JulianDate.addSeconds(clockViewModel.systemTime, -30, new JulianDate());
        expect(viewModel.playRealtimeViewModel.command.canExecute).toEqual(false);
        expect(viewModel.playRealtimeViewModel.tooltip).toEqual('Current time not in range');

        //LOOP_STOP but available when start/stop time includes realtime
        clockViewModel.clockRange = ClockRange.LOOP_STOP;
        clockViewModel.startTime = JulianDate.addSeconds(clockViewModel.systemTime, -60, new JulianDate());
        clockViewModel.stopTime = JulianDate.addSeconds(clockViewModel.systemTime, 60, new JulianDate());
        expect(viewModel.playRealtimeViewModel.command.canExecute).toEqual(true);
        expect(viewModel.playRealtimeViewModel.tooltip).toEqual('Today (real-time)');
    });

    it('User action breaks out of realtime mode', function() {
        var viewModel = new AnimationViewModel(clockViewModel);
        clockViewModel.clockStep = ClockStep.TICK_DEPENDENT;
        clockViewModel.clockRange = ClockRange.UNBOUNDED;

        viewModel.playRealtimeViewModel.command();
        verifyRealtimeState(viewModel);
        expect(clockViewModel.multiplier).toEqual(1);

        //Pausing breaks realtime state
        viewModel.pauseViewModel.command();
        verifyPausedState(viewModel);
        expect(clockViewModel.multiplier).toEqual(1);

        viewModel.playRealtimeViewModel.command();
        verifyRealtimeState(viewModel);

        //Reverse breaks realtime state
        viewModel.playReverseViewModel.command();
        verifyReverseState(viewModel);
        expect(clockViewModel.multiplier).toEqual(-1);

        viewModel.playRealtimeViewModel.command();
        verifyRealtimeState(viewModel);

        //Play does not break realtime state
        viewModel.playForwardViewModel.command();
        verifyRealtimeState(viewModel);
        expect(clockViewModel.multiplier).toEqual(1);

        viewModel.playRealtimeViewModel.command();
        verifyRealtimeState(viewModel);

        //Shuttle ring change breaks realtime state
        viewModel.shuttleRingAngle = viewModel.shuttleRingAngle + 1;
        verifyForwardState(viewModel);
    });

    it('real time mode toggles off but not back on when shouldAnimate changes', function() {
        var viewModel = new AnimationViewModel(clockViewModel);

        viewModel.playRealtimeViewModel.command();
        verifyRealtimeState(viewModel);

        clockViewModel.shouldAnimate = false;
        expect(viewModel.playRealtimeViewModel.toggled).toEqual(false);

        clockViewModel.shouldAnimate = true;
        expect(viewModel.playRealtimeViewModel.toggled).toEqual(false);
    });

    it('Shuttle ring angles set expected multipliers', function() {
        var viewModel = new AnimationViewModel(clockViewModel);

        var shuttleRingTicks = viewModel.getShuttleRingTicks();
        var maxMultiplier = shuttleRingTicks[shuttleRingTicks.length - 1];
        var minMultiplier = -maxMultiplier;

        //Max angle should produce max speed
        viewModel.shuttleRingAngle = AnimationViewModel._maxShuttleRingAngle;
        expect(clockViewModel.multiplier).toEqual(maxMultiplier);

        //Min angle should produce min speed
        viewModel.shuttleRingAngle = -AnimationViewModel._maxShuttleRingAngle;
        expect(clockViewModel.multiplier).toEqual(minMultiplier);

        //AnimationViewModel._realtimeShuttleRingAngle degrees is always 1x
        viewModel.shuttleRingAngle = AnimationViewModel._realtimeShuttleRingAngle;
        expect(clockViewModel.multiplier).toEqual(1);

        viewModel.shuttleRingAngle = -AnimationViewModel._realtimeShuttleRingAngle;
        expect(clockViewModel.multiplier).toEqual(-1);

        //For large values, the shuttleRingAngle should always round to the first two digits.
        viewModel.shuttleRingAngle = 45.0;
        expect(clockViewModel.multiplier).toEqual(85.0);

        viewModel.shuttleRingAngle = -90.0;
        expect(clockViewModel.multiplier).toEqual(-66000.0);

        viewModel.shuttleRingAngle = 0.0;
        expect(clockViewModel.multiplier).toEqual(0.0);
    });

    it('Shuttle ring angles set expected multipliers when snapping to ticks', function() {
        var viewModel = new AnimationViewModel(clockViewModel);
        viewModel.snapToTicks = true;

        var shuttleRingTicks = viewModel.getShuttleRingTicks();
        var maxMultiplier = shuttleRingTicks[shuttleRingTicks.length - 1];
        var minMultiplier = -maxMultiplier;

        //Max angle should produce max speed
        viewModel.shuttleRingAngle = AnimationViewModel._maxShuttleRingAngle;
        expect(clockViewModel.multiplier).toEqual(maxMultiplier);

        //Min angle should produce min speed
        viewModel.shuttleRingAngle = -AnimationViewModel._maxShuttleRingAngle;
        expect(clockViewModel.multiplier).toEqual(minMultiplier);

        //AnimationViewModel._realtimeShuttleRingAngle degrees is always 1x
        viewModel.shuttleRingAngle = AnimationViewModel._realtimeShuttleRingAngle;
        expect(clockViewModel.multiplier).toEqual(1);

        viewModel.shuttleRingAngle = -AnimationViewModel._realtimeShuttleRingAngle;
        expect(clockViewModel.multiplier).toEqual(-1);

        //For large values, the shuttleRingAngle should always round to the first two digits.
        viewModel.shuttleRingAngle = 45.0;
        expect(clockViewModel.multiplier).toEqual(120.0);

        viewModel.shuttleRingAngle = -90.0;
        expect(clockViewModel.multiplier).toEqual(-43200.0);

        viewModel.shuttleRingAngle = 0.0;
        expect(clockViewModel.multiplier).toEqual(AnimationViewModel.defaultTicks[0]);
    });

    it('throws when constructed without arguments', function() {
        expect(function() {
            return new AnimationViewModel();
        }).toThrowDeveloperError();
    });

    it('setting timeFormatter throws with non-function', function() {
        var animationViewModel = new AnimationViewModel(clockViewModel);
        expect(function() {
            animationViewModel.timeFormatter = {};
        }).toThrowDeveloperError();
    });

    it('setting dateFormatter throws with non-function', function() {
        var animationViewModel = new AnimationViewModel(clockViewModel);
        expect(function() {
            animationViewModel.dateFormatter = {};
        }).toThrowDeveloperError();
    });

    it('setting shuttleRingTicks throws with undefined', function() {
        var animationViewModel = new AnimationViewModel(clockViewModel);
        expect(function() {
            animationViewModel.setShuttleRingTicks(undefined);
        }).toThrowDeveloperError();
    });

    it('returns a copy of shuttleRingTicks when getting', function() {
        var animationViewModel = new AnimationViewModel(clockViewModel);
        var originalTicks = [0.0, 1.0, 2.0];
        animationViewModel.setShuttleRingTicks(originalTicks);

        var ticks = animationViewModel.getShuttleRingTicks();
        ticks.push(99);
        ticks[0] = -99;
        expect(animationViewModel.getShuttleRingTicks()).toEqual(originalTicks);
    });

    it('sorts shuttleRingTicks when setting', function() {
        var animationViewModel = new AnimationViewModel(clockViewModel);
        var ticks = [4.0, 0.0, 8.0, 2.0];

        animationViewModel.setShuttleRingTicks(ticks);
        expect(animationViewModel.getShuttleRingTicks()).toEqual([0.0, 2.0, 4.0, 8.0]);
    });
});
